﻿#define  _CRT_SECURE_NO_WARNINGS   1
#include <iostream>
#include<assert.h>
#include<string.h>
#include<algorithm>
using namespace std;

//初始化
//C++实现了统一初始化的方式。
//内置类型和自定义类型都可以使用{ }进行初始化

template<class T>
class vector {
public:
	typedef T* iterator;
	vector(initializer_list<T> l)		//初始化列表也是支持迭代器的===>begin() end()
	{
		for (auto e : l)
			push_back(e);
	}
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;
};
void test()
{
	//int a0={ 20 };
	//int a1 =20;
	//cout << a0<< endl;
	//cout << a1<< endl;

	//右值引用&&
	//左值：能取地址就是左值。可以出现在=的左边或右边
	//右值：字面常量，匿名对象，临时对象，运算表达式。必须出现在=的右边
	//左值可以修改，右值是不可以修改的
	//int a = 3.4;
	/*int&& a = 2;
	a = a + 1;*/

	//左值不可以引用右值，除非加个const ，右值不可以引用左值，使用move
	//变量表达式具有左值属性
	int d = 1;		//左值
	int&& a =move(d);		//使用move==>右值
	int& c = a;
	cout << d << endl;
	cout << a << endl;
	cout << c<< endl;
}

//int main()
//{
//	test();
//	return 0;
//}

void f(int& x)
{
	cout << "左值引⽤重载 f(int&)" << endl;;
}
void f(const int& x)
{
	cout << "到 const 的左值引⽤重载 f(const int&)"<<endl;
}
void f(int&& x)
{
	cout << "右值引⽤重载 f(int&&)" << endl;;
}
//int main()
//{
//	int i = 1;
//	const int ci = 2;
//	f(i); // 调⽤ f(int&)
//	f(ci); // 调⽤ f(const int&)
//	f(3); // 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)
//	f(std::move(i)); // 调⽤ f(int&&)
//	// 右值引⽤变量在⽤于表达式时是左值
//	int&& x = 1;
//	f(x); // 调⽤ f(int& x)
//	f(std::move(x)); // 调⽤ f(int&& x)
//	return 0;
//}

namespace bit
{
class string
{
	friend ostream& operator<<(ostream& out, bit::string& s);
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷⻉构造" << endl;

reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷⻉赋值" <<
endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
~string()
{
cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
}

char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity *2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}

size_t size() const
{
return _size;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
ostream& operator<<(ostream& out, bit::string& s)
{
	out << s._str << endl;
	return out;
}
}

int main()
{
	//bit::string s1("xxxxx");
	//// 拷⻉构造
	////bit::string s2 = s1;
	////// 构造+移动构造，优化后直接构造
	////bit::string s3 = bit::string("yyyyy");
	//// 移动构造
	////bit::string s4 = move(s1);
	//bit::string s4 ( move(s1));

	//cout << "******************************" << endl;
	//cout << s1 << endl;

	//lambda表达式
	//在语法层面上是没有类型的，所以一般使用auto或模板
	//auto it = [](int x, int y)->int {return x + y; };		//it类似于函数指针
	//auto it = [](int x, int y)
	//	{
	//		return x + y;
	//	};
	//cout <<it(1,2)<< endl;

	//auto it = [](int x, int y)->int {return x + y; };	有返回值时，必须要->
	int a = 10;
	int c = 30;
	//auto it = [a,c]()			//传值捕捉，捕捉对象不可修改
	//	{ 

	//		cout << "无参" << endl; 
	//		cout << a << endl; 
	//		cout << c << endl; 
	//	};
		//auto it = [&a,&c]()			//引用捕捉，捕捉对象可修改
		//{ 

		//	cout << "无参" << endl; 
		//	cout << ++a << endl; 
		//	cout << ++c << endl; 
		//};

	//auto it = [&]()			//全部引用捕捉，捕捉对象可修改
	//	{

	//		cout << "无参" << endl;
	//		cout << ++a << endl;
	//		cout << ++c << endl;
	//	};
	auto it = [=]()			//全部传值捕捉，捕捉对象可修改
		{

			cout << "无参" << endl;
			//cout << ++a << endl;			error
			//cout << ++c << endl;			error
		};
	it();
	return 0;
}